
function ifArray (value) {
    return value instanceof Array || Object.prototype.toString.call(value) === '[object Array]';
}

function ifObject (value) {
    return Object.prototype.toString.call(value) === '[object Object]' ;
}

function ifExist(arr, ran) {
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] === ran) {
            return true;
        }
    }
    return false;
}

function ifEmpty(o) {
    // 判断数据data的类型
    const s = Object.prototype.toString.call(o).slice(8, -1);
    let statusValue = false;
    switch (s) {
        case 'String':
            statusValue = o === ''
            break
        case 'Boolean':
            statusValue = o === false
            break
        case 'Null':
        case 'Undefined':
            statusValue = true
            break
        case 'Object':
            statusValue = Object.keys(o).length === 0
            break
        case 'Array':
            statusValue = o.length === 0
            break
        case 'Number':
            statusValue = false
            break
        default:
            statusValue = !o
    }
    return statusValue
}

function ifUrl(url) {
    const regexp = /(http|https):\/\/([\w.]+\/?)\S*/;
    return regexp.test(url);
}

function ifImage(url) {
    const regexp = /\.(png|jpg|jpeg|gif|bmp|webp|svg)$/i;
    return regexp.test(url);
}

/**
 * 数组或对象深拷贝
 * @param data
 * @returns {any}
 */
const nextArr = (data) => {
    if (!data) return {};
    return JSON.parse(JSON.stringify(data));
};

/**
 * 深度合并两个对象
 * @param {Object} target - 目标对象（将被合并的原始对象）
 * @param {Object} source - 源对象（要合并进来的对象）
 * @returns {Object} - 合并后的对象
 */
function deepMerge(target, source) {
    // 处理 null/undefined 情况
    if (target === null || target === undefined) {
        return source;
    }
    if (source === null || source === undefined) {
        return target;
    }

    // 如果 source 不是对象，直接返回 source
    if (typeof source !== 'object') {
        return source;
    }

    // 如果 target 不是对象，直接覆盖
    if (typeof target !== 'object') {
        return source;
    }

    // 创建新对象避免修改原始对象
    const result = { ...target };

    for (const key in source) {
        if (source.hasOwnProperty(key)) {
            const targetValue = result[key];
            const sourceValue = source[key];

            // 如果两个值都是对象（且不是数组），递归合并
            if (ifPlainObject(targetValue) && ifPlainObject(sourceValue)) {
                result[key] = deepMerge(targetValue, sourceValue);
            }
            // 如果两个值都是数组，合并数组（这里我们选择替换数组，而不是递归合并数组元素）
            else if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
                result[key] = [...targetValue, ...sourceValue]; // 合并数组（也可以选择替换：sourceValue）
            }
            // 其他情况：直接覆盖
            else {
                result[key] = sourceValue;
            }
        }
    }

    return result;
}

/**
 * 判断是否为普通对象（非数组、非null、非函数）
 * @param {any} value - 要检查的值
 * @returns {boolean} - 是否为普通对象
 */
function ifPlainObject(value) {
    return value !== null &&
        typeof value === 'object' &&
        !Array.isArray(value) &&
        value.constructor === Object;
}

/**
 * 深度展开对象（将嵌套对象转换为扁平结构）
 * @param {Object} obj - 要展开的对象
 * @param {string} [prefix=''] - 用于递归的前缀
 * @param {string} [symbol='.'] - 链接符
 * @param {Object} [result={}] - 用于存储结果的中间对象
 * @returns {Object} - 展开后的扁平对象
 */
function deepExpand(obj, prefix = '', symbol='.',  result = {}) {
    for (const key in obj) {
        if (obj.hasOwnProperty(key)) {
            const newKey = prefix ? `${prefix}${symbol}${key}` : key;
            if (typeof obj[key] === 'object' && obj[key] !== null && !Array.isArray(obj[key])) {
                // 递归处理嵌套对象
                deepExpand(obj[key], newKey, symbol, result);
            } else {
                // 处理基本类型值
                result[newKey] = obj[key];
            }
        }
    }
    return result;
}

/**
 * 深度聚合对象（将扁平结构转换为嵌套对象）
 * @param {Object} obj - 要聚合的对象
 * @param {string} [symbol='.'] - 链接符
 * @param {Object} [result={}] - 用于存储结果的中间对象
 * @returns {Object} - 聚合后的嵌套对象
 */
function deepAggregate(obj, symbol = '.', result = {}) {
    for (const key in obj) {
        if (obj.hasOwnProperty(key)) {
            const keys = key.split(symbol);
            let current = result;
            for (let i = 0; i < keys.length; i++) {
                const k = keys[i];
                if (!current[k]) {
                    current[k] = {};
                }
                if (i === keys.length - 1) {
                    current[k] = obj[key];
                }
                current = current[k];
            }
        }
    }
    return result;
}

module.exports = {
    ifArray,
    ifObject,
    ifExist,
    ifEmpty,
    ifUrl,
    ifImage,
    nextArr,
    deepMerge,
    deepExpand,
    deepAggregate,
}